home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / tiff / tif_dir.c < prev    next >
C/C++ Source or Header  |  1995-06-21  |  30KB  |  1,117 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_dir.c,v 1.138 1994/09/19 23:52:15 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994 Sam Leffler
  5.  * Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * TIFF Library.
  29.  *
  30.  * Directory Tag Get & Set Routines.
  31.  * (and also some miscellaneous stuff)
  32.  */
  33. #include "tiffiop.h"
  34.  
  35. static void
  36. setString(char** cpp, char* cp)
  37. {
  38.     if (*cpp)
  39.         _TIFFfree(*cpp), *cpp = 0;
  40.     if (cp) {
  41.         size_t len = strlen(cp)+1;
  42.         if (*cpp = (char*)_TIFFmalloc(len))
  43.             _TIFFmemcpy(*cpp, cp, len);
  44.     }
  45. }
  46.  
  47. static void
  48. setShortArray(uint16** wpp, uint16* wp, long n)
  49. {
  50.     if (*wpp)
  51.         _TIFFfree((char *)*wpp), *wpp = 0;
  52.     n *= sizeof (uint16);
  53.     if (wp && (*wpp = (uint16 *)_TIFFmalloc(n)))
  54.         _TIFFmemcpy(*wpp, wp, n);
  55. }
  56.  
  57. #if SUBIFD_SUPPORT
  58. static void
  59. setLongArray(uint32** lpp, uint32* lp, long n)
  60. {
  61.     if (*lpp)
  62.         _TIFFfree((char *)*lpp), *lpp = 0;
  63.     n *= sizeof (uint32);
  64.     if (lp && (*lpp = (uint32 *)_TIFFmalloc(n)))
  65.         _TIFFmemcpy(*lpp, lp, n);
  66. }
  67. #endif
  68.  
  69. static void
  70. setFloatArray(float** wpp, float* wp, long n)
  71. {
  72.     if (*wpp)
  73.         _TIFFfree((char *)*wpp), *wpp = 0;
  74.     n *= sizeof (float);
  75.     if (wp && (*wpp = (float *)_TIFFmalloc(n)))
  76.         _TIFFmemcpy(*wpp, wp, n);
  77. }
  78.  
  79. #ifdef JPEG_SUPPORT
  80. /*
  81.  * Install a JPEG Quantization table.
  82.  * Note that we reorder the elements
  83.  * of the array in the zig-zag order
  84.  * that is expected by the compression code
  85.  * and that is to be stored in the file.
  86.  */
  87. static void
  88. setJPEGQTable(u_char*** wpp, u_char** wp, int nc)
  89. {
  90.     static u_char zigzag[64] = {
  91.         0,  1,  5,  6, 14, 15, 27, 28,
  92.         2,  4,  7, 13, 16, 26, 29, 42,
  93.         3,  8, 12, 17, 25, 30, 41, 43,
  94.         9, 11, 18, 24, 31, 40, 44, 53,
  95.        10, 19, 23, 32, 39, 45, 52, 54,
  96.        20, 22, 33, 38, 46, 51, 55, 60,
  97.        21, 34, 37, 47, 50, 56, 59, 61,
  98.        35, 36, 48, 49, 57, 58, 62, 63
  99.     };
  100.     char *tab;
  101.     int i, j;
  102.  
  103.     if (*wpp)
  104.         _TIFFfree((char *)*wpp), *wpp = 0;
  105.     *wpp = (u_char **)
  106.         _TIFFmalloc(nc * (sizeof (u_char *) + 64*sizeof (u_char)));
  107.     tab = (((char *)*wpp) + nc*sizeof (u_char *));
  108.     for (i = 0; i < nc; i++) {
  109.         (*wpp)[i] = (u_char *)tab;
  110.         for (j = 0; j < 64; j++)
  111.             tab[zigzag[j]] = wp[i][j];
  112.         tab += 64*sizeof (u_char);
  113.     }
  114. }
  115.  
  116. /*
  117.  * Install a JPEG Coefficient table.
  118.  */
  119. static void
  120. setJPEGCTable(u_char*** cpp, u_char** cp, int nc)
  121. {
  122.     u_char *tab;
  123.     int i, j, nw;
  124.  
  125.     if (*cpp)
  126.         _TIFFfree(*cpp), *cpp = 0;
  127.     /*
  128.      * Calculate the size of the table by counting
  129.      * the number of codes specified in the bits array.
  130.      */
  131.     nw = 0;
  132.     for (i = 0; i < nc; i++) {
  133.         nw += 16;        /* 16 bytes for bits array */
  134.         for (j = 0; j < 16; j++)/* sum up count of codes */
  135.             nw += cp[i][j];
  136.     }
  137.     *cpp = (u_char **)_TIFFmalloc(nc*sizeof (u_char *) + nw);
  138.     tab = ((u_char *)*cpp) + nc*sizeof (u_char *);
  139.     /*
  140.      * Setup internal array and copy user data.
  141.      */
  142.     for (i = 0; i < nc; i++) {
  143.         (*cpp)[i] = tab;
  144.         for (nw = 16, j = 0; j < 16; j++)
  145.             nw += cp[i][j];
  146.         _TIFFmemcpy(tab, cp[i], nw);
  147.         tab += nw;
  148.     }
  149. }
  150. #endif
  151.  
  152. /*
  153.  * Install extra samples information.
  154.  */
  155. static int
  156. setExtraSamples(TIFFDirectory* td, va_list ap, int* v)
  157. {
  158.     uint16* va;
  159.     int i;
  160.  
  161.     *v = va_arg(ap, int);
  162.     if (*v > td->td_samplesperpixel)
  163.         return (0);
  164.     va = va_arg(ap, uint16*);
  165.     if (va == NULL)            /* typically missing param */
  166.         return (0);
  167.     for (i = 0; i < *v; i++)
  168.         if (va[i] > EXTRASAMPLE_UNASSALPHA)
  169.             return (0);
  170.     td->td_extrasamples = *v;
  171.     setShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
  172.     return (1);
  173. }
  174.  
  175. static int
  176. TIFFSetField1(TIFF* tif, ttag_t tag, va_list ap)
  177. {
  178.     TIFFDirectory *td = &tif->tif_dir;
  179.     int status = 1;
  180.     uint32 v32;
  181.     int i, v;
  182.  
  183.     switch (tag) {
  184.     case TIFFTAG_SUBFILETYPE:
  185.         td->td_subfiletype = va_arg(ap, uint32);
  186.         break;
  187.     case TIFFTAG_IMAGEWIDTH:
  188.         td->td_imagewidth = va_arg(ap, uint32);
  189.         break;
  190.     case TIFFTAG_IMAGELENGTH:
  191.         td->td_imagelength = va_arg(ap, uint32);
  192.         break;
  193.     case TIFFTAG_BITSPERSAMPLE:
  194.         td->td_bitspersample = va_arg(ap, int);
  195.         /*
  196.          * If the data require post-decoding processing
  197.          * to byte-swap samples, set it up here.  Note
  198.          * that since tags are required to be ordered,
  199.          * compression code can override this behaviour
  200.          * in the setup method if it wants to roll the
  201.          * post decoding work in with its normal work.
  202.          */
  203.         if (tif->tif_flags & TIFF_SWAB) {
  204.             if (td->td_bitspersample == 16)
  205.                 tif->tif_postdecode = TIFFSwab16BitData;
  206.             else if (td->td_bitspersample == 32)
  207.                 tif->tif_postdecode = TIFFSwab32BitData;
  208.         }
  209.         break;
  210.     case TIFFTAG_COMPRESSION:
  211.         v = va_arg(ap, int) & 0xffff;
  212.         /*
  213.          * If we're changing the compression scheme,
  214.          * the notify the previous module so that it
  215.          * can cleanup any state it's setup.
  216.          */
  217.         if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
  218.             if (td->td_compression == v)
  219.                 break;
  220.             if (tif->tif_cleanup)
  221.                 (*tif->tif_cleanup)(tif);
  222.         }
  223.         /*
  224.          * Setup new compression routine state.
  225.          */
  226.         if (status = TIFFSetCompressionScheme(tif, v))
  227.             td->td_compression = v;
  228.         break;
  229.     case TIFFTAG_PHOTOMETRIC:
  230.         td->td_photometric = va_arg(ap, int);
  231.         break;
  232.     case TIFFTAG_THRESHHOLDING:
  233.         td->td_threshholding = va_arg(ap, int);
  234.         break;
  235.     case TIFFTAG_FILLORDER:
  236.         v = va_arg(ap, int);
  237.         if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
  238.             goto badvalue;
  239.         td->td_fillorder = v;
  240.         break;
  241.     case TIFFTAG_DOCUMENTNAME:
  242.         setString(&td->td_documentname, va_arg(ap, char *));
  243.         break;
  244.     case TIFFTAG_ARTIST:
  245.         setString(&td->td_artist, va_arg(ap, char *));
  246.         break;
  247.     case TIFFTAG_DATETIME:
  248.         setString(&td->td_datetime, va_arg(ap, char *));
  249.         break;
  250.     case TIFFTAG_HOSTCOMPUTER:
  251.         setString(&td->td_hostcomputer, va_arg(ap, char *));
  252.         break;
  253.     case TIFFTAG_IMAGEDESCRIPTION:
  254.         setString(&td->td_imagedescription, va_arg(ap, char *));
  255.         break;
  256.     case TIFFTAG_MAKE:
  257.         setString(&td->td_make, va_arg(ap, char *));
  258.         break;
  259.     case TIFFTAG_MODEL:
  260.         setString(&td->td_model, va_arg(ap, char *));
  261.         break;
  262.     case TIFFTAG_SOFTWARE:
  263.         setString(&td->td_software, va_arg(ap, char *));
  264.         break;
  265.     case TIFFTAG_ORIENTATION:
  266.         v = va_arg(ap, int);
  267.         if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
  268.             TIFFWarning(tif->tif_name,
  269.                 "Bad value %ld for \"%s\" tag ignored",
  270.                 v, TIFFFieldWithTag(tag)->field_name);
  271.         } else
  272.             td->td_orientation = v;
  273.         break;
  274.     case TIFFTAG_SAMPLESPERPIXEL:
  275.         /* XXX should cross check -- e.g. if pallette, then 1 */
  276.         v = va_arg(ap, int);
  277.         if (v == 0)
  278.             goto badvalue;
  279.         td->td_samplesperpixel = v;
  280.         break;
  281.     case TIFFTAG_ROWSPERSTRIP:
  282.         v32 = va_arg(ap, uint32);
  283.         if (v32 == 0)
  284.             goto badvalue32;
  285.         td->td_rowsperstrip = v32;
  286.         if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  287.             td->td_tilelength = v32;
  288.             td->td_tilewidth = td->td_imagewidth;
  289.         }
  290.         break;
  291.     case TIFFTAG_MINSAMPLEVALUE:
  292.         td->td_minsamplevalue = (uint16) va_arg(ap, int);
  293.         break;
  294.     case TIFFTAG_MAXSAMPLEVALUE:
  295.         td->td_maxsamplevalue = (uint16) va_arg(ap, int);
  296.         break;
  297.     case TIFFTAG_XRESOLUTION:
  298.         td->td_xresolution = va_arg(ap, dblparam_t);
  299.         break;
  300.     case TIFFTAG_YRESOLUTION:
  301.         td->td_yresolution = va_arg(ap, dblparam_t);
  302.         break;
  303.     case TIFFTAG_PLANARCONFIG:
  304.         v = va_arg(ap, int);
  305.         if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
  306.             goto badvalue;
  307.         td->td_planarconfig = v;
  308.         break;
  309.     case TIFFTAG_PAGENAME:
  310.         setString(&td->td_pagename, va_arg(ap, char *));
  311.         break;
  312.     case TIFFTAG_XPOSITION:
  313.         td->td_xposition = va_arg(ap, dblparam_t);
  314.         break;
  315.     case TIFFTAG_YPOSITION:
  316.         td->td_yposition = va_arg(ap, dblparam_t);
  317.         break;
  318.     case TIFFTAG_GROUP3OPTIONS:
  319.         td->td_group3options = va_arg(ap, uint32);
  320.         break;
  321.     case TIFFTAG_GROUP4OPTIONS:
  322.         td->td_group4options = va_arg(ap, uint32);
  323.         break;
  324.     case TIFFTAG_RESOLUTIONUNIT:
  325.         v = va_arg(ap, int);
  326.         if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
  327.             goto badvalue;
  328.         td->td_resolutionunit = v;
  329.         break;
  330.     case TIFFTAG_PAGENUMBER:
  331.         td->td_pagenumber[0] = va_arg(ap, int);
  332.         td->td_pagenumber[1] = va_arg(ap, int);
  333.         break;
  334.     case TIFFTAG_HALFTONEHINTS:
  335.         td->td_halftonehints[0] = va_arg(ap, int);
  336.         td->td_halftonehints[1] = va_arg(ap, int);
  337.         break;
  338.     case TIFFTAG_COLORMAP:
  339.         v32 = (uint32)(1L<<td->td_bitspersample);
  340.         setShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);
  341.         setShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);
  342.         setShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
  343.         break;
  344.     case TIFFTAG_PREDICTOR:
  345.         td->td_predictor = va_arg(ap, int);
  346.         break;
  347.     case TIFFTAG_EXTRASAMPLES:
  348.         if (!setExtraSamples(td, ap, &v))
  349.             goto badvalue;
  350.         break;
  351.     case TIFFTAG_MATTEING:
  352.         td->td_extrasamples = (va_arg(ap, int) != 0);
  353.         if (td->td_extrasamples) {
  354.             uint16 sv = EXTRASAMPLE_ASSOCALPHA;
  355.             setShortArray(&td->td_sampleinfo, &sv, 1);
  356.         }
  357.         break;
  358.     case TIFFTAG_BADFAXLINES:
  359.         td->td_badfaxlines = va_arg(ap, uint32);
  360.         break;
  361.     case TIFFTAG_CLEANFAXDATA:
  362.         td->td_cleanfaxdata = va_arg(ap, int);
  363.         break;
  364.     case TIFFTAG_CONSECUTIVEBADFAXLINES:
  365.         td->td_badfaxrun = va_arg(ap, uint32);
  366.         break;
  367.     case TIFFTAG_TILEWIDTH:
  368.         v32 = va_arg(ap, uint32);
  369.         if (v32 % 16)
  370.             goto badvalue32;
  371.         td->td_tilewidth = v32;
  372.         tif->tif_flags |= TIFF_ISTILED;
  373.         break;
  374.     case TIFFTAG_TILELENGTH:
  375.         v32 = va_arg(ap, uint32);
  376.         if (v32 % 16)
  377.             goto badvalue32;
  378.         td->td_tilelength = v32;
  379.         tif->tif_flags |= TIFF_ISTILED;
  380.         break;
  381.     case TIFFTAG_TILEDEPTH:
  382.         v32 = va_arg(ap, uint32);
  383.         if (v32 == 0)
  384.             goto badvalue32;
  385.         td->td_tiledepth = v32;
  386.         break;
  387.     case TIFFTAG_DATATYPE:
  388.     case TIFFTAG_SAMPLEFORMAT:
  389.         v = va_arg(ap, int);
  390.         if (tag == TIFFTAG_DATATYPE && v == 0)
  391.             v = SAMPLEFORMAT_VOID;
  392.         if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_VOID < v)
  393.             goto badvalue;
  394.         td->td_sampleformat = v;
  395.         break;
  396.     case TIFFTAG_IMAGEDEPTH:
  397.         td->td_imagedepth = va_arg(ap, uint32);
  398.         break;
  399. #if SUBIFD_SUPPORT
  400.     case TIFFTAG_SUBIFD:
  401.         if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {
  402.             td->td_nsubifd = (uint16) va_arg(ap, int);
  403.             setLongArray(&td->td_subifd, va_arg(ap, uint32*),
  404.                 (long) td->td_nsubifd);
  405.         } else {
  406.             TIFFError(tif->tif_name, "Sorry, cannot nest SubIFDs");
  407.             status = 0;
  408.         }
  409.         break;
  410. #endif
  411. #ifdef YCBCR_SUPPORT
  412.     case TIFFTAG_YCBCRCOEFFICIENTS:
  413.         setFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float *), 3);
  414.         break;
  415.     case TIFFTAG_YCBCRPOSITIONING:
  416.         td->td_ycbcrpositioning = va_arg(ap, int);
  417.         break;
  418.     case TIFFTAG_YCBCRSUBSAMPLING:
  419.         td->td_ycbcrsubsampling[0] = va_arg(ap, int);
  420.         td->td_ycbcrsubsampling[1] = va_arg(ap, int);
  421.         break;
  422. #endif
  423. #ifdef JPEG_SUPPORT
  424.     case TIFFTAG_JPEGPROC:
  425.         td->td_jpegproc = va_arg(ap, int);
  426.         break;
  427.     case TIFFTAG_JPEGRESTARTINTERVAL:
  428.         td->td_jpegrestartinterval = va_arg(ap, int);
  429.         break;
  430.     case TIFFTAG_JPEGQTABLES:
  431.         setJPEGQTable(&td->td_qtab, va_arg(ap, u_char **),
  432.             td->td_samplesperpixel);
  433.         break;
  434.     case TIFFTAG_JPEGDCTABLES:
  435.         setJPEGCTable(&td->td_dctab, va_arg(ap, u_char **),
  436.             td->td_samplesperpixel);
  437.         break;
  438.     case TIFFTAG_JPEGACTABLES:
  439.         setJPEGCTable(&td->td_actab, va_arg(ap, u_char **),
  440.             td->td_samplesperpixel);
  441.         break;
  442. #endif
  443. #ifdef COLORIMETRY_SUPPORT
  444.     case TIFFTAG_WHITEPOINT:
  445.         setFloatArray(&td->td_whitepoint, va_arg(ap, float *), 2);
  446.         break;
  447.     case TIFFTAG_PRIMARYCHROMATICITIES:
  448.         setFloatArray(&td->td_primarychromas, va_arg(ap, float *), 6);
  449.         break;
  450.     case TIFFTAG_TRANSFERFUNCTION:
  451.         v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
  452.         for (i = 0; i < v; i++)
  453.             setShortArray(&td->td_transferfunction[i],
  454.                 va_arg(ap, uint16*), 1L<<td->td_bitspersample);
  455.         break;
  456.     case TIFFTAG_REFERENCEBLACKWHITE:
  457.         /* XXX should check for null range */
  458.         setFloatArray(&td->td_refblackwhite, va_arg(ap, float *), 6);
  459.         break;
  460. #endif
  461. #ifdef CMYK_SUPPORT
  462.     case TIFFTAG_INKSET:
  463.         td->td_inkset = va_arg(ap, int);
  464.         break;
  465.     case TIFFTAG_DOTRANGE:
  466.         /* XXX should check for null range */
  467.         td->td_dotrange[0] = va_arg(ap, int);
  468.         td->td_dotrange[1] = va_arg(ap, int);
  469.         break;
  470.     case TIFFTAG_INKNAMES:
  471.         setString(&td->td_inknames, va_arg(ap, char *));
  472.         break;
  473.     case TIFFTAG_TARGETPRINTER:
  474.         setString(&td->td_targetprinter, va_arg(ap, char *));
  475.         break;
  476. #endif
  477.     default:
  478.         TIFFError(tif->tif_name,
  479.             "Internal error, tag value botch, tag \"%s\"",
  480.             TIFFFieldWithTag(tag)->field_name);
  481.         status = 0;
  482.         break;
  483.     }
  484.     if (status) {
  485.         TIFFSetFieldBit(tif, TIFFFieldWithTag(tag)->field_bit);
  486.         tif->tif_flags |= TIFF_DIRTYDIRECT;
  487.     }
  488.     va_end(ap);
  489.     return (status);
  490. badvalue:
  491.     TIFFError(tif->tif_name, "%d: Bad value for \"%s\"", v,
  492.         TIFFFieldWithTag(tag)->field_name);
  493.     va_end(ap);
  494.     return (0);
  495. badvalue32:
  496.     TIFFError(tif->tif_name, "%ld: Bad value for \"%s\"", v32,
  497.         TIFFFieldWithTag(tag)->field_name);
  498.     va_end(ap);
  499.     return (0);
  500. }
  501.  
  502. /*
  503.  * Return 1/0 according to whether or not
  504.  * it is permissible to set the tag's value.
  505.  * Note that we allow ImageLength to be changed
  506.  * so that we can append and extend to images.
  507.  * Any other tag may not be altered once writing
  508.  * has commenced, unless its value has no effect
  509.  * on the format of the data that is written.
  510.  */
  511. static int
  512. OkToChangeTag(TIFF* tif, ttag_t tag)
  513. {
  514.     if (tag != TIFFTAG_IMAGELENGTH &&
  515.         (tif->tif_flags & TIFF_BEENWRITING)) {
  516.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  517.         /*
  518.          * Consult info table to see if tag can be changed
  519.          * after we've started writing.  We only allow changes
  520.          * to those tags that don't/shouldn't affect the
  521.          * compression and/or format of the data.
  522.          */
  523.         if (fip && !fip->field_oktochange)
  524.             return (0);
  525.     }
  526.     return (1);
  527. }
  528.  
  529. /*
  530.  * Record the value of a field in the
  531.  * internal directory structure.  The
  532.  * field will be written to the file
  533.  * when/if the directory structure is
  534.  * updated.
  535.  */
  536. int
  537. TIFFSetField(TIFF* tif, ttag_t tag, ...)
  538. {
  539.     int status = 0;
  540.  
  541.     if (OkToChangeTag(tif, tag)) {
  542.         va_list ap;
  543.  
  544.         va_start(ap, tag);
  545.         status = TIFFSetField1(tif, tag, ap);
  546.         va_end(ap);
  547.     } else {
  548.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  549.         if (fip)
  550.             TIFFError("TIFFSetField",
  551.                 "%s: Cannot modify tag \"%s\" while writing",
  552.                 tif->tif_name, fip->field_name);
  553.     }
  554.     return (status);
  555. }
  556.  
  557. /*
  558.  * Like TIFFSetField, but taking a varargs
  559.  * parameter list.  This routine is useful
  560.  * for building higher-level interfaces on
  561.  * top of the library.
  562.  */
  563. int
  564. TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
  565. {
  566.     int status = 0;
  567.  
  568.     if (!OkToChangeTag(tif, tag)) {
  569.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  570.         if (fip)
  571.             TIFFError("TIFFVSetField",
  572.                 "%s: Cannot modify tag \"%s\" while writing",
  573.                 tif->tif_name, fip->field_name);
  574.     } else
  575.         status = TIFFSetField1(tif, tag, ap);
  576.     return (status);
  577. }
  578.  
  579. static void
  580. TIFFGetField1(TIFFDirectory* td, ttag_t tag, va_list ap)
  581. {
  582.     switch (tag) {
  583.     case TIFFTAG_SUBFILETYPE:
  584.         *va_arg(ap, uint32*) = td->td_subfiletype;
  585.         break;
  586.     case TIFFTAG_IMAGEWIDTH:
  587.         *va_arg(ap, uint32*) = td->td_imagewidth;
  588.         break;
  589.     case TIFFTAG_IMAGELENGTH:
  590.         *va_arg(ap, uint32*) = td->td_imagelength;
  591.         break;
  592.     case TIFFTAG_BITSPERSAMPLE:
  593.         *va_arg(ap, uint16*) = td->td_bitspersample;
  594.         break;
  595.     case TIFFTAG_COMPRESSION:
  596.         *va_arg(ap, uint16*) = td->td_compression;
  597.         break;
  598.     case TIFFTAG_PHOTOMETRIC:
  599.         *va_arg(ap, uint16*) = td->td_photometric;
  600.         break;
  601.     case TIFFTAG_THRESHHOLDING:
  602.         *va_arg(ap, uint16*) = td->td_threshholding;
  603.         break;
  604.     case TIFFTAG_FILLORDER:
  605.         *va_arg(ap, uint16*) = td->td_fillorder;
  606.         break;
  607.     case TIFFTAG_DOCUMENTNAME:
  608.         *va_arg(ap, char **) = td->td_documentname;
  609.         break;
  610.     case TIFFTAG_ARTIST:
  611.         *va_arg(ap, char **) = td->td_artist;
  612.         break;
  613.     case TIFFTAG_DATETIME:
  614.         *va_arg(ap, char **) = td->td_datetime;
  615.         break;
  616.     case TIFFTAG_HOSTCOMPUTER:
  617.         *va_arg(ap, char **) = td->td_hostcomputer;
  618.         break;
  619.     case TIFFTAG_IMAGEDESCRIPTION:
  620.         *va_arg(ap, char **) = td->td_imagedescription;
  621.         break;
  622.     case TIFFTAG_MAKE:
  623.         *va_arg(ap, char **) = td->td_make;
  624.         break;
  625.     case TIFFTAG_MODEL:
  626.         *va_arg(ap, char **) = td->td_model;
  627.         break;
  628.     case TIFFTAG_SOFTWARE:
  629.         *va_arg(ap, char **) = td->td_software;
  630.         break;
  631.     case TIFFTAG_ORIENTATION:
  632.         *va_arg(ap, uint16*) = td->td_orientation;
  633.         break;
  634.     case TIFFTAG_SAMPLESPERPIXEL:
  635.         *va_arg(ap, uint16*) = td->td_samplesperpixel;
  636.         break;
  637.     case TIFFTAG_ROWSPERSTRIP:
  638.         *va_arg(ap, uint32*) = td->td_rowsperstrip;
  639.         break;
  640.     case TIFFTAG_MINSAMPLEVALUE:
  641.         *va_arg(ap, uint16*) = td->td_minsamplevalue;
  642.         break;
  643.     case TIFFTAG_MAXSAMPLEVALUE:
  644.         *va_arg(ap, uint16*) = td->td_maxsamplevalue;
  645.         break;
  646.     case TIFFTAG_XRESOLUTION:
  647.         *va_arg(ap, float *) = td->td_xresolution;
  648.         break;
  649.     case TIFFTAG_YRESOLUTION:
  650.         *va_arg(ap, float *) = td->td_yresolution;
  651.         break;
  652.     case TIFFTAG_PLANARCONFIG:
  653.         *va_arg(ap, uint16*) = td->td_planarconfig;
  654.         break;
  655.     case TIFFTAG_XPOSITION:
  656.         *va_arg(ap, float *) = td->td_xposition;
  657.         break;
  658.     case TIFFTAG_YPOSITION:
  659.         *va_arg(ap, float *) = td->td_yposition;
  660.         break;
  661.     case TIFFTAG_PAGENAME:
  662.         *va_arg(ap, char **) = td->td_pagename;
  663.         break;
  664.     case TIFFTAG_GROUP3OPTIONS:
  665.         *va_arg(ap, uint32*) = td->td_group3options;
  666.         break;
  667.     case TIFFTAG_GROUP4OPTIONS:
  668.         *va_arg(ap, uint32*) = td->td_group4options;
  669.         break;
  670.     case TIFFTAG_RESOLUTIONUNIT:
  671.         *va_arg(ap, uint16*) = td->td_resolutionunit;
  672.         break;
  673.     case TIFFTAG_PAGENUMBER:
  674.         *va_arg(ap, uint16*) = td->td_pagenumber[0];
  675.         *va_arg(ap, uint16*) = td->td_pagenumber[1];
  676.         break;
  677.     case TIFFTAG_HALFTONEHINTS:
  678.         *va_arg(ap, uint16*) = td->td_halftonehints[0];
  679.         *va_arg(ap, uint16*) = td->td_halftonehints[1];
  680.         break;
  681.     case TIFFTAG_COLORMAP:
  682.         *va_arg(ap, uint16**) = td->td_colormap[0];
  683.         *va_arg(ap, uint16**) = td->td_colormap[1];
  684.         *va_arg(ap, uint16**) = td->td_colormap[2];
  685.         break;
  686.     case TIFFTAG_PREDICTOR:
  687.         *va_arg(ap, uint16*) = td->td_predictor;
  688.         break;
  689.     case TIFFTAG_STRIPOFFSETS:
  690.     case TIFFTAG_TILEOFFSETS:
  691.         *va_arg(ap, uint32**) = td->td_stripoffset;
  692.         break;
  693.     case TIFFTAG_STRIPBYTECOUNTS:
  694.     case TIFFTAG_TILEBYTECOUNTS:
  695.         *va_arg(ap, uint32**) = td->td_stripbytecount;
  696.         break;
  697.     case TIFFTAG_MATTEING:
  698.         *va_arg(ap, uint16*) =
  699.             (td->td_extrasamples == 1 &&
  700.              td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
  701.         break;
  702.     case TIFFTAG_EXTRASAMPLES:
  703.         *va_arg(ap, uint16*) = td->td_extrasamples;
  704.         *va_arg(ap, uint16**) = td->td_sampleinfo;
  705.         break;
  706.     case TIFFTAG_BADFAXLINES:
  707.         *va_arg(ap, uint32*) = td->td_badfaxlines;
  708.         break;
  709.     case TIFFTAG_CLEANFAXDATA:
  710.         *va_arg(ap, uint16*) = td->td_cleanfaxdata;
  711.         break;
  712.     case TIFFTAG_CONSECUTIVEBADFAXLINES:
  713.         *va_arg(ap, uint32*) = td->td_badfaxrun;
  714.         break;
  715.     case TIFFTAG_TILEWIDTH:
  716.         *va_arg(ap, uint32*) = td->td_tilewidth;
  717.         break;
  718.     case TIFFTAG_TILELENGTH:
  719.         *va_arg(ap, uint32*) = td->td_tilelength;
  720.         break;
  721.     case TIFFTAG_TILEDEPTH:
  722.         *va_arg(ap, uint32*) = td->td_tiledepth;
  723.         break;
  724.     case TIFFTAG_DATATYPE:
  725.         *va_arg(ap, uint16*) =
  726.             (td->td_sampleformat == SAMPLEFORMAT_VOID ?
  727.             0 : td->td_sampleformat);
  728.         break;
  729.     case TIFFTAG_SAMPLEFORMAT:
  730.         *va_arg(ap, uint16*) = td->td_sampleformat;
  731.         break;
  732.     case TIFFTAG_IMAGEDEPTH:
  733.         *va_arg(ap, uint32*) = td->td_imagedepth;
  734.         break;
  735. #if SUBIFD_SUPPORT
  736.     case TIFFTAG_SUBIFD:
  737.         *va_arg(ap, uint16*) = td->td_nsubifd;
  738.         *va_arg(ap, uint32**) = td->td_subifd;
  739.         break;
  740. #endif
  741. #ifdef YCBCR_SUPPORT
  742.     case TIFFTAG_YCBCRCOEFFICIENTS:
  743.         *va_arg(ap, float **) = td->td_ycbcrcoeffs;
  744.         break;
  745.     case TIFFTAG_YCBCRPOSITIONING:
  746.         *va_arg(ap, uint16*) = td->td_ycbcrpositioning;
  747.         break;
  748.     case TIFFTAG_YCBCRSUBSAMPLING:
  749.         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];
  750.         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];
  751.         break;
  752. #endif
  753. #ifdef JPEG_SUPPORT
  754.     case TIFFTAG_JPEGPROC:
  755.         *va_arg(ap, uint16*) = td->td_jpegproc;
  756.         break;
  757.     case TIFFTAG_JPEGRESTARTINTERVAL:
  758.         *va_arg(ap, uint16*) = td->td_jpegrestartinterval;
  759.         break;
  760.     case TIFFTAG_JPEGQTABLES:
  761.         *va_arg(ap, u_char ***) = td->td_qtab;
  762.         break;
  763.     case TIFFTAG_JPEGDCTABLES:
  764.         *va_arg(ap, u_char ***) = td->td_dctab;
  765.         break;
  766.     case TIFFTAG_JPEGACTABLES:
  767.         *va_arg(ap, u_char ***) = td->td_actab;
  768.         break;
  769. #endif
  770. #ifdef COLORIMETRY_SUPPORT
  771.     case TIFFTAG_WHITEPOINT:
  772.         *va_arg(ap, float **) = td->td_whitepoint;
  773.         break;
  774.     case TIFFTAG_PRIMARYCHROMATICITIES:
  775.         *va_arg(ap, float **) = td->td_primarychromas;
  776.         break;
  777.     case TIFFTAG_TRANSFERFUNCTION:
  778.         *va_arg(ap, uint16**) = td->td_transferfunction[0];
  779.         if (td->td_samplesperpixel - td->td_extrasamples > 1) {
  780.             *va_arg(ap, uint16**) = td->td_transferfunction[1];
  781.             *va_arg(ap, uint16**) = td->td_transferfunction[2];
  782.         }
  783.         break;
  784.     case TIFFTAG_REFERENCEBLACKWHITE:
  785.         *va_arg(ap, float **) = td->td_refblackwhite;
  786.         break;
  787. #endif
  788. #ifdef CMYK_SUPPORT
  789.     case TIFFTAG_INKSET:
  790.         *va_arg(ap, uint16*) = td->td_inkset;
  791.         break;
  792.     case TIFFTAG_DOTRANGE:
  793.         *va_arg(ap, uint16*) = td->td_dotrange[0];
  794.         *va_arg(ap, uint16*) = td->td_dotrange[1];
  795.         break;
  796.     case TIFFTAG_INKNAMES:
  797.         *va_arg(ap, char **) = td->td_inknames;
  798.         break;
  799.     case TIFFTAG_TARGETPRINTER:
  800.         *va_arg(ap, char **) = td->td_targetprinter;
  801.         break;
  802. #endif
  803.     default:
  804.         TIFFError("TIFFGetField1",
  805.             "Internal error, no value returned for tag \"%s\"",
  806.             TIFFFieldWithTag(tag)->field_name);
  807.         break;
  808.     }
  809.     va_end(ap);
  810. }
  811.  
  812. /*
  813.  * Return the value of a field in the
  814.  * internal directory structure.
  815.  */
  816. int
  817. TIFFGetField(TIFF* tif, ttag_t tag, ...)
  818. {
  819.     const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  820.  
  821.     if (fip) {
  822.         u_short bit = fip->field_bit;
  823.         if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
  824.             va_list ap;
  825.             va_start(ap, tag);
  826.             TIFFGetField1(&tif->tif_dir, tag, ap);
  827.             va_end(ap);
  828.             return (1);
  829.         }
  830.     } else
  831.         TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
  832.     return (0);
  833. }
  834.  
  835. /*
  836.  * Like TIFFGetField, but taking a varargs
  837.  * parameter list.  This routine is useful
  838.  * for building higher-level interfaces on
  839.  * top of the library.
  840.  */
  841. int
  842. TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
  843. {
  844.     const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  845.  
  846.     if (fip) {
  847.         u_short bit = fip->field_bit;
  848.         if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
  849.             TIFFGetField1(&tif->tif_dir, tag, ap);
  850.             return (1);
  851.         }
  852.     } else
  853.         TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
  854.     return (0);
  855. }
  856.  
  857. /*
  858.  * Internal interface to TIFFGetField...
  859.  */
  860. void
  861. _TIFFgetfield(TIFFDirectory* td, ttag_t tag, ...)
  862. {
  863.     va_list ap;
  864.     va_start(ap, tag);
  865.     TIFFGetField1(td, tag, ap);
  866.     va_end(ap);
  867. }
  868.  
  869. #define    CleanupField(member) {        \
  870.     if (td->member) {            \
  871.     _TIFFfree((char *)td->member);    \
  872.     td->member = 0;            \
  873.     }                    \
  874. }
  875.  
  876. /*
  877.  * Release storage associated with a directory.
  878.  */
  879. void
  880. TIFFFreeDirectory(TIFF* tif)
  881. {
  882.     register TIFFDirectory *td = &tif->tif_dir;
  883.  
  884.     CleanupField(td_colormap[0]);
  885.     CleanupField(td_colormap[1]);
  886.     CleanupField(td_colormap[2]);
  887.     CleanupField(td_documentname);
  888.     CleanupField(td_artist);
  889.     CleanupField(td_datetime);
  890.     CleanupField(td_hostcomputer);
  891.     CleanupField(td_imagedescription);
  892.     CleanupField(td_make);
  893.     CleanupField(td_model);
  894.     CleanupField(td_software);
  895.     CleanupField(td_pagename);
  896.     CleanupField(td_sampleinfo);
  897. #if SUBIFD_SUPPORT
  898.     CleanupField(td_subifd);
  899. #endif
  900. #ifdef YCBCR_SUPPORT
  901.     CleanupField(td_ycbcrcoeffs);
  902. #endif
  903. #ifdef JPEG_SUPPORT
  904.     CleanupField(td_qtab);
  905.     CleanupField(td_dctab);
  906.     CleanupField(td_actab);
  907. #endif
  908. #ifdef CMYK_SUPPORT
  909.     CleanupField(td_inknames);
  910.     CleanupField(td_targetprinter);
  911. #endif
  912. #ifdef COLORIMETRY_SUPPORT
  913.     CleanupField(td_whitepoint);
  914.     CleanupField(td_primarychromas);
  915.     CleanupField(td_refblackwhite);
  916.     CleanupField(td_transferfunction[0]);
  917.     CleanupField(td_transferfunction[1]);
  918.     CleanupField(td_transferfunction[2]);
  919. #endif
  920.     CleanupField(td_stripoffset);
  921.     CleanupField(td_stripbytecount);
  922. }
  923. #undef CleanupField
  924.  
  925. /*
  926.  * Setup a default directory structure.
  927.  */
  928. int
  929. TIFFDefaultDirectory(TIFF* tif)
  930. {
  931.     register TIFFDirectory *td = &tif->tif_dir;
  932.  
  933.     _TIFFmemset(td, 0, sizeof (*td));
  934.     td->td_fillorder = FILLORDER_MSB2LSB;
  935.     td->td_bitspersample = 1;
  936.     td->td_threshholding = THRESHHOLD_BILEVEL;
  937.     td->td_orientation = ORIENTATION_TOPLEFT;
  938.     td->td_samplesperpixel = 1;
  939.     td->td_predictor = 1;
  940.     td->td_rowsperstrip = (uint32) -1;
  941.     td->td_tilewidth = (uint32) -1;
  942.     td->td_tilelength = (uint32) -1;
  943.     td->td_tiledepth = 1;
  944.     td->td_resolutionunit = RESUNIT_INCH;
  945.     td->td_sampleformat = SAMPLEFORMAT_VOID;
  946.     td->td_imagedepth = 1;
  947. #ifdef YCBCR_SUPPORT
  948.     td->td_ycbcrsubsampling[0] = 2;
  949.     td->td_ycbcrsubsampling[1] = 2;
  950.     td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
  951. #endif
  952. #ifdef CMYK_SUPPORT
  953.     td->td_inkset = INKSET_CMYK;
  954. #endif
  955.     (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  956.     /*
  957.      * NB: The directory is marked dirty as a result of setting
  958.      * up the default compression scheme.  However, this really
  959.      * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
  960.      * if the user does something.  We could just do the setup
  961.      * by hand, but it seems better to use the normal mechanism
  962.      * (i.e. TIFFSetField).
  963.      */
  964.     tif->tif_flags &= ~TIFF_DIRTYDIRECT;
  965.     return (1);
  966. }
  967.  
  968. static int
  969. TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off)
  970. {
  971.     static const char module[] = "TIFFAdvanceDirectory";
  972.     uint16 dircount;
  973.  
  974.     if (!SeekOK(tif, *nextdir) ||
  975.         !ReadOK(tif, &dircount, sizeof (uint16))) {
  976.         TIFFError(module, "%s: Error fetching directory count",
  977.             tif->tif_name);
  978.         return (0);
  979.     }
  980.     if (tif->tif_flags & TIFF_SWAB)
  981.         TIFFSwabShort(&dircount);
  982.     if (off != NULL)
  983.         *off = TIFFSeekFile(tif,
  984.             dircount*sizeof (TIFFDirEntry), L_INCR);
  985.     else
  986.         (void) TIFFSeekFile(tif,
  987.             dircount*sizeof (TIFFDirEntry), L_INCR);
  988.     if (!ReadOK(tif, nextdir, sizeof (uint32))) {
  989.         TIFFError(module, "%s: Error fetching directory link",
  990.             tif->tif_name);
  991.         return (0);
  992.     }
  993.     if (tif->tif_flags & TIFF_SWAB)
  994.         TIFFSwabLong(nextdir);
  995.     return (1);
  996. }
  997.  
  998. /*
  999.  * Set the n-th directory as the current directory.
  1000.  * NB: Directories are numbered starting at 0.
  1001.  */
  1002. int
  1003. TIFFSetDirectory(TIFF* tif, tdir_t dirn)
  1004. {
  1005.     uint32 nextdir;
  1006.     tdir_t n;
  1007.  
  1008.     nextdir = tif->tif_header.tiff_diroff;
  1009.     for (n = dirn; n > 0 && nextdir != 0; n--)
  1010.         if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
  1011.             return (0);
  1012.     tif->tif_nextdiroff = nextdir;
  1013.     /*
  1014.      * Set curdir to the actual directory index.  The
  1015.      * -1 is because TIFFReadDirectory will increment
  1016.      * tif_curdir after successfully reading the directory.
  1017.      */
  1018.     tif->tif_curdir = (dirn - n) - 1;
  1019.     return (TIFFReadDirectory(tif));
  1020. }
  1021.  
  1022. /*
  1023.  * Set the current directory to be the directory
  1024.  * located at the specified file offset.  This interface
  1025.  * is used mainly to access directories linked with
  1026.  * the SubIFD tag (e.g. thumbnail images).
  1027.  */
  1028. int
  1029. TIFFSetSubDirectory(TIFF* tif, uint32 diroff)
  1030. {
  1031.     tif->tif_nextdiroff = diroff;
  1032.     return (TIFFReadDirectory(tif));
  1033. }
  1034.  
  1035. /*
  1036.  * Return an indication of whether or not we are
  1037.  * at the last directory in the file.
  1038.  */
  1039. int
  1040. TIFFLastDirectory(TIFF* tif)
  1041. {
  1042.     return (tif->tif_nextdiroff == 0);
  1043. }
  1044.  
  1045. /*
  1046.  * Unlink the specified directory from the directory chain.
  1047.  */
  1048. int
  1049. TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn)
  1050. {
  1051.     static const char module[] = "TIFFUnlinkDirectory";
  1052.     uint32 nextdir;
  1053.     toff_t off;
  1054.     tdir_t n;
  1055.  
  1056.     if (tif->tif_mode == O_RDONLY) {
  1057.         TIFFError(module, "Can not unlink directory in read-only file");
  1058.         return (0);
  1059.     }
  1060.     /*
  1061.      * Go to the directory before the one we want
  1062.      * to unlink and nab the offset of the link
  1063.      * field we'll need to patch.
  1064.      */
  1065.     nextdir = tif->tif_header.tiff_diroff;
  1066.     off = sizeof (uint16) + sizeof (uint16);
  1067.     for (n = dirn-1; n > 0; n--) {
  1068.         if (nextdir == 0) {
  1069.             TIFFError(module, "Directory %d does not exist", dirn);
  1070.             return (0);
  1071.         }
  1072.         if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
  1073.             return (0);
  1074.     }
  1075.     /*
  1076.      * Advance to the directory to be unlinked and fetch
  1077.      * the offset of the directory that follows.
  1078.      */
  1079.     if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
  1080.         return (0);
  1081.     /*
  1082.      * Go back and patch the link field of the preceding
  1083.      * directory to point to the offset of the directory
  1084.      * that follows.
  1085.      */
  1086.     (void) TIFFSeekFile(tif, off, L_SET);
  1087.     if (tif->tif_flags & TIFF_SWAB)
  1088.         TIFFSwabLong(&nextdir);
  1089.     if (!WriteOK(tif, &nextdir, sizeof (uint32))) {
  1090.         TIFFError(module, "Error writing directory link");
  1091.         return (0);
  1092.     }
  1093.     /*
  1094.      * Leave directory state setup safely.  We don't have
  1095.      * facilities for doing inserting and removing directories,
  1096.      * so it's safest to just invalidate everything.  This
  1097.      * means that the caller can only append to the directory
  1098.      * chain.
  1099.      */
  1100.     if (tif->tif_cleanup)
  1101.         (*tif->tif_cleanup)(tif);
  1102.     if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
  1103.         _TIFFfree(tif->tif_rawdata);
  1104.         tif->tif_rawdata = NULL;
  1105.         tif->tif_rawcc = 0;
  1106.     }
  1107.     tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE);
  1108.     TIFFFreeDirectory(tif);
  1109.     TIFFDefaultDirectory(tif);
  1110.     tif->tif_diroff = 0;            /* force link on next write */
  1111.     tif->tif_nextdiroff = 0;        /* next write must be at end */
  1112.     tif->tif_curoff = 0;
  1113.     tif->tif_row = (uint32) -1;
  1114.     tif->tif_curstrip = (tstrip_t) -1;
  1115.     return (1);
  1116. }
  1117.